Get a User by UserName

This example demonstrates how to find and delete users, roles and tenants.

The example uses API authentication driven from JavaScript. See Authentication APIs for alternatives.

// URL of the Pyramid installation and the path to the API 3.0 REST methods
var pyramidURL = "http://mysite.com/api3/";

// step 1: authenticate admin account and get token
// NOTE: callApi method is a generic REST method shown below.
let token = callApi("authentication/authenticateUser",{
	"userName":"adminUser1",
		"password":"abc123!"
},"",false);
log("got token "+token);

//########## user ################

//step 2: searching for a user by it's name
let findUser= callApi("access/getUsersByName", {
	"searchValue":"john"
	}, token // admin token generated above
);
				
// get user ID				
let userId=findUser[0].id;
				
log("found user with id= "+ userId);

//step 3: deleting the role
let deleteUser=callApi("access/deleteUser", userId, //from step 2
	token // admin token generated above
	);


//########## role ################

//step 4: searching for a role by it's name
let findRole= callApi("access/findRoles",{
	"searchValue": "test role",
	"searchMatchType": 2// search flag enumerations. 2 = SearchMatchType.Equals
},token);
// get role ID	
let roleId=findRole[0].roleId;
				
log("found role with id= "+ roleId);

//step 5: deleting the role
let deleteRole=callApi("access/deleteRole", roleId, // from step 4
	token);


//########## tenant ################

//step 6: search for tenant
let findTenenat=callApi("access/getTenantByName","Test Tenant 1",token);
// get tenant ID					
let tenantId=findTenenat.id;
				
log("found tenant by name "+ tenantId);

//step 7: delete the tenant we found in step 2
let deleteTenants=callApi("access/deleteTenants",{
	"tenantIds": [
		tenantId
	], // use the array method, because it can accept multiple ID's
	"deleteUsers": true, //delete all tenant users
	"deleteServers": true //delete all data source servers associated with tenant
},token);



// ##### optional generic logging method for debugging ##############
function log(msg){
	document.write(msg);
	console.log(msg);
}

// ##### generic REST API calling method ##############
function callApi(path,data,token="",parseResult=true){
	var xhttp = new XMLHttpRequest();
	xhttp.open("POST", pyramidURL+path, false);
	xhttp.setRequestHeader("paToken",token)
	xhttp.send(JSON.stringify(data));
	if(parseResult){
		return JSON.parse(xhttp.responseText);
	}else{
		return xhttp.responseText;
	}
}

		

This example demonstrates how to authenticate users for the main application.

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.json.simple.JSONObject;

import java.io.IOException;
import java.net.InetSocketAddress;

public class Main {
	private static final String pyramidPath = "http://mySite.com/API3/";

	public static void main(String[] args) throws IOException {
		HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
		server.createContext("/login", new LoginHandler());


		server.setExecutor(null); // creates a default executor
		server.start();

	}

	private static class LoginHandler implements HttpHandler {
		@Override
		public void handle(HttpExchange httpExchange) throws IOException {
			//logging the user
			JSONObject adminCredentials = new JSONObject();
			adminCredentials.put("userName", "testUser1");
			adminCredentials.put("password", "abc456!");
			String adminToken = getToken("authenticateUser", adminCredentials);

			//logging the user in using the admin's token
			JSONObject userCredentials = new JSONObject();
			userCredentials.put("userIdentity", "test.user1@mySite.com");
			userCredentials.put("token", adminToken);

			String userToken = getToken("authenticateUserByToken", userCredentials);

			//searching the user by name 
			JSONObject results = callApi("access/getUsersByName", "testUser1", adminToken);
			String userId = ((JSONObject) ((JSONArray) results.get("data")).get(0)).get("id").toString();

			//reading the user's private folder
			JSONObject privateFolder = callApi("content/getFolderItems", 
				userId,//the user private folder id is the same as the user id
				adminToken
			);
			String messageStr = "private folder id is " + userId + " and it contains ";
			JSONArray folderContent = ((JSONArray) privateFolder.get("data"));
			for (int i = 0; i < folderContent.size(); ++i) {
				messageStr += ((JSONObject) folderContent.get(i)).get("caption") + ",";
			}

			byte[] message = messageStr.getBytes(StandardCharsets.UTF_8);
			httpExchange.getResponseHeaders().add("Set-Cookie", "PyramidAuth=" + userToken);
			httpExchange.sendResponseHeaders(200, message.length);
			httpExchange.getResponseBody().write(message);
		}
	}


	protected static String getToken(String service, JSONObject data) throws IOException {
		return sendPost("authentication/" + service, data.toJSONString(),null);
	}


	protected static String sendPost(String path, String data, String token) throws IOException {
		try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {

			String address = pyramidPath + path;
			HttpPost request = new HttpPost(address);
			StringEntity params = new StringEntity(data);
			request.addHeader("content-type", "application/x-www-form-urlencoded");
			if (token !=null) {
				request.addHeader("paToken", token);
			}
			request.setEntity(params);
			CloseableHttpResponse response = httpClient.execute(request);
			return new BasicResponseHandler().handleResponse(response);
		}
	}
}